
#ifndef _a78ec1d4_d112_433e_b74f_72ffbee7f1dd__TUPLE_H__
#define _a78ec1d4_d112_433e_b74f_72ffbee7f1dd__TUPLE_H__


template <typename A=void, typename B=void, typename C=void,
	typename D=void, typename E=void, typename F=void,
	typename G=void, typename H=void>
struct tuple 
{
	tuple(){}
	tuple(const A& a_,
		const B& b_,
		const C& c_,
		const D& d_,
		const E& e_,
		const F& f_,
		const G& g_,
		const H& h_)
		: a(a_), b(b_), c(c_), d(d_), e(e_), f(f_), g(g_), h(h_) {}

	void copy(const A& a_,
		const B& b_,
		const C& c_,
		const D& d_,
		const E& e_,
		const F& f_,
		const G& g_,
		const H& h_)
	{
		a = a_;
		b = b_;
		c = c_;
		d = d_;
		e = e_;
		f = f_;
		g = g_;
		h = h_;
	}
	A a;
	B b;
	C c;
	D d;
	E e;
	F f;
	G g;
	H h;
};

template <typename A, typename B, typename C,typename D, typename E, typename F,typename G>
struct tuple<A, B, C, D, E, F, G,void>
{
	tuple(){}
	tuple(const A& a_,
		const B& b_,
		const C& c_,
		const D& d_,
		const E& e_,
		const F& f_,
		const G& g_)
		: a(a_), b(b_), c(c_), d(d_), e(e_), f(f_), g(g_) {}

	void copy(const A& a_,
		const B& b_,
		const C& c_,
		const D& d_,
		const E& e_,
		const F& f_,
		const G& g_)
	{
		a = a_;
		b = b_;
		c = c_;
		d = d_;
		e = e_;
		f = f_;
		g = g_;
	}

	A a;
	B b;
	C c;
	D d;
	E e;
	F f;
	G g;
};

template <typename A, typename B, typename C,typename D, typename E, typename F>
struct tuple <A, B, C, D, E, F, void,void>
{
	tuple(){}
	tuple(const A& a_,
		const B& b_,
		const C& c_,
		const D& d_,
		const E& e_,
		const F& f_)
		: a(a_), b(b_), c(c_), d(d_), e(e_), f(f_) {}

	void copy(const A& a_,
		const B& b_,
		const C& c_,
		const D& d_,
		const E& e_,
		const F& f_)
	{
		a = a_;
		b = b_;
		c = c_;
		d = d_;
		e = e_;
		f = f_;
	}

	A a;
	B b;
	C c;
	D d;
	E e;
	F f;
};

template <typename A, typename B, typename C,typename D, typename E>
struct tuple<A, B, C, D, E, void, void, void> 
{
	tuple() {}
	tuple(const A& a_,
		const B& b_,
		const C& c_,
		const D& d_,
		const E& e_)
		: a(a_), b(b_), c(c_), d(d_), e(e_) {}

	void copy(const A& a_,
		const B& b_,
		const C& c_,
		const D& d_,
		const E& e_)
	{
		a = a_;
		b = b_;
		c = c_;
		d = d_;
		e = e_;
	}

	A a;
	B b;
	C c;
	D d;
	E e;
};

template <typename A, typename B, typename C, typename D>
struct tuple<A, B, C, D, void, void, void, void> 
{
	tuple() {}
	tuple(const A& a_,
		const B& b_,
		const C& c_,
		const D& d_)
		: a(a_), b(b_), c(c_), d(d_) {}

	void copy(const A& a_,
		const B& b_,
		const C& c_,
		const D& d_)
	{
		a = a_;
		b = b_;
		c = c_;
		d = d_;
	}

	A a;
	B b;
	C c;
	D d;
};

template <typename A, typename B, typename C>
struct tuple<A, B, C, void, void, void, void, void> 
{
	tuple() {}
	tuple(const A& a_,
		const B& b_,
		const C& c_)
		: a(a_), b(b_), c(c_) {}

	void copy(const A& a_,
		const B& b_,
		const C& c_)
	{
		a = a_;
		b = b_;
		c = c_;
	}

	A a;
	B b;
	C c;
};

template <typename A, typename B>
struct tuple<A, B, void, void, void, void, void, void> 
{
	tuple() {}
	tuple(const A& a_,
		const B& b_)
		: a(a_), b(b_) {}

	void copy(const A& a_,
		const B& b_)
	{
		a = a_;
		b = b_;
	}

	A a;
	B b;
};

template <typename A>
struct tuple<A, void, void, void, void, void, void, void> 
{
	tuple() {}
	tuple(const A& a_)
		: a(a_) {}

	void copy(const A& a_)
	{
		a = a_;
	}
	A a;
};

template <> 
struct tuple<void, void, void, void, void, void, void, void> {};

#endif //_a78ec1d4_d112_433e_b74f_72ffbee7f1dd__TUPLE_H__